home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpat2-1.000 / xpat2-1 / xpat2-1.04 / src / X-cards.c < prev    next >
C/C++ Source or Header  |  1995-01-23  |  5KB  |  182 lines
  1. /*****************************************************************************/
  2. /*                                         */
  3. /*                                         */
  4. /*    X patience version 2 -- module X-cards.c                 */
  5. /*                                         */
  6. /*    Card drawing interface for X11                         */
  7. /*    written by Heiko Eissfeldt and Michael Bischoff                 */
  8. /*    see COPYRIGHT.xpat2 for Copyright details                 */
  9. /*                                         */
  10. /*                                         */
  11. /*****************************************************************************/
  12. #include "X-pat.h"
  13.  
  14. struct graphic graphic;
  15. struct card card;
  16. int table_clear = 1;
  17.  
  18. void win_game(void) {
  19. #if 0
  20. #ifdef useXlib
  21.     XMoveWindow(dpy, finished_win, (graphic.width - FINISHED_W) / 2,
  22.         (graphic.height - FINISHED_H) / 2);
  23.     XMapWindow(dpy, finished_win);
  24.     redraw_finwin((XExposeEvent *)0);    /* must unmap it later! */
  25. #endif
  26. #endif
  27. #ifdef useXview
  28.     xv_set(xv_default_server, SERVER_SYNC, FALSE, 0);
  29. #else
  30.     XSync(dpy, 0);    /* show all requests and let it be for now */
  31. #endif
  32. }
  33.  
  34.  
  35. void init_gfx(void) {
  36.     XGCValues gcv;
  37.     long gcflags;
  38.  
  39.     blackpixel = BlackPixel(dpy, screen);
  40.     whitepixel = WhitePixel(dpy, screen);
  41.     
  42.     
  43.     /* make gc for white */
  44.     gcv.foreground = WhitePixel(dpy, screen);
  45.     gcv.background = BlackPixel(dpy, screen);
  46.     gcv.graphics_exposures = False;
  47.     gcflags = GCForeground | GCBackground | GCGraphicsExposures;
  48.     
  49.     whitegc = XCreateGC(dpy, RootWindow(dpy, screen), gcflags, &gcv);
  50.     
  51.     /* make gc for black */
  52.     gcv.foreground = BlackPixel(dpy, screen);
  53.     gcv.background = WhitePixel(dpy, screen);
  54.     gcflags = GCForeground | GCBackground | GCGraphicsExposures;
  55.     
  56.     blackgc = XCreateGC(dpy, RootWindow(dpy, screen), gcflags, &gcv);
  57. }
  58.  
  59.  
  60. /* this is a helper routine only called by do_move(): */
  61. /* it transfers card game.which is unknown to the generic part */
  62. /* these transfers do not necessarily affect the appearance on the screen, */
  63. /* they are needed due to the design of the game.structures as arrays */
  64. /* instead of linked lists */
  65.  
  66.  
  67. void move_card_data(Cardindex dst, Cardindex src) {
  68.     game.cards[dst] = game.cards[src];
  69.     game.visible[dst] = game.visible[src];
  70.     graphic.cardy[dst] = graphic.cardy[src];
  71. }
  72.  
  73.  
  74. void refresh_screen(void) {
  75. #ifdef LABER
  76.     printf("refresh_screen called\n");
  77. #endif
  78.     if (table_clear) {
  79. #ifdef LABER
  80.     printf("(ignored)\n");
  81. #endif
  82.     return;
  83.     }
  84.     table_clear = 1;
  85.     XClearArea(dpy, table, 0, 0, 0, 0, True);    /* force redraw */
  86. }
  87.  
  88. /* all card drawings go through this routine:                 */
  89. /* inform the graphics interface that cards are added (delta > 0)    */
  90. /* or removed (delta < 0) from the specified pile. if delta = 0,     */
  91. /* then redrawing of the complete pile is necessary (possibly caused */
  92. /* by "new game" commands)                         */
  93. /* if cards on the pile are marked (selected), the mark is refreshed */
  94.  
  95. void draw_pileupdate(int pile, int delta) {
  96.     struct pile *p = graphic.pile + pile;
  97.  
  98.     if (!game.graphic) {        /* this is off when replaying saved games */
  99.     /* only log changes */
  100.     if (game.pile_changed[pile] == PILE_UNCHANGED)
  101.         game.pile_changed[pile] = delta;
  102.     else
  103.         if ((delta > 0 && game.pile_changed[pile] > 0) ||
  104.         (delta < 0 && game.pile_changed[pile] < 0))
  105.         game.pile_changed[pile] += delta;
  106.         else
  107.         game.pile_changed[pile] = 0;
  108.         return;
  109.     }
  110.     if (game.disable[pile])    /* don't draw THIS pile */
  111.     return;
  112.     if (NOT_DISPLAYED(p))
  113.     return;            /* draw nothing */
  114.     if (EMPTY(pile)) {        /* draw empty pile */
  115.     int c;
  116.     XClearArea(dpy, table, p->x, p->y, p->xmaxwidth, p->ymaxheight, False);
  117.     switch (game.piletype[pile]) {
  118.     case Stack:
  119.         c = SUITSYMBOL + SUIT(pile);
  120.         break;
  121.     default:
  122.         c = OUTLINE;
  123.         break;
  124.     }
  125.     PaintCard(p->x, p->y, c, 0);
  126.     return;
  127.     }
  128.     if (!p->delta && !p->xdelta) {    /* only topmost card is visible */
  129.     Cardindex c;
  130.     c = INDEX_OF_LAST_CARD(pile);
  131.     PaintCard(p->x, p->y, game.visible[c] ? game.cards[c] : CARDBACK, 0);
  132.     } else {
  133.  
  134.     if (pile_resize(pile))    /* delta changed => complete redraw */
  135.         delta = 0;
  136.     
  137.     if (delta < 0) {    /* cards were removed. Clear area and redraw top */
  138.         int x, y;
  139.         if (p->xdelta) {
  140.         x = (CARDS_ON_PILE(pile)-1) * p->xdelta + CARD_WIDTH - ROUND_W;
  141.         y = (CARDS_ON_PILE(pile)-1) * p->delta;
  142.         XClearArea(dpy, table, p->x+x, p->y+y, p->xmaxwidth-x, p->ymaxheight-y, False);
  143.         }
  144.         if (p->delta) {
  145.         x = (CARDS_ON_PILE(pile)-1) * p->xdelta;
  146.         y = (CARDS_ON_PILE(pile)-1) * p->delta + CARD_HEIGHT - ROUND_H;
  147.         XClearArea(dpy, table, p->x+x, p->y+y, p->xmaxwidth-x, p->ymaxheight-y, False);
  148.         }
  149.         delta = 1;    /* only last card is to be drawn new */
  150.     } else if (!delta) {    /* draw complete pile */
  151.         XClearArea(dpy, table, p->x, p->y, p->xmaxwidth, p->ymaxheight, False);
  152.         delta = CARDS_ON_PILE(pile);
  153.     }
  154.     /* (delta > 0) */
  155.     /* draw last cards */
  156.     {   Cardindex c = INDEX_OF_LAST_CARD(pile) + 1 - delta;
  157.         int i = c - INDEX_OF_FIRST_CARD(pile); 
  158.         if (!p->xdelta) {
  159.         /* may use card clipping optimisation */
  160.         while (delta > 1) {
  161.             /* not the last card */
  162.             --delta;
  163.             PaintCard(p->x + p->xdelta*i, p->y + p->delta*i,
  164.                   (game.visible[c] ? game.cards[c] : CARDBACK), p->delta);
  165.             ++c;
  166.             ++i;
  167.         }
  168.         }
  169.         while (--delta >= 0) {
  170.         PaintCard(p->x + p->xdelta*i, p->y + p->delta*i,
  171.               (game.visible[c] ? game.cards[c] : CARDBACK), 0);
  172.         ++c;
  173.         ++i;
  174.         }
  175.     }
  176.     }
  177.     if (game.srcind >= 0 && getpile(game.srcind) == pile)
  178.     show_mark(True);
  179. }
  180.  
  181.  
  182.